home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / dpmigcc5.zip / RSX / SOURCE / DJLIBRSX / SPAWNVE.C < prev    next >
C/C++ Source or Header  |  1994-05-27  |  5KB  |  210 lines
  1. #include <stdlib.h>
  2. #include <stdarg.h>
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <sys/_process.h>
  6.  
  7. void search_path(char *file, char *path);
  8.  
  9. struct _new_proc {
  10.     unsigned long arg_off;
  11.     unsigned long env_off;
  12.     unsigned long fname_off;
  13.     unsigned short arg_sel;
  14.     unsigned short env_sel;
  15.     unsigned short fname_sel;
  16.     unsigned short arg_count;
  17.     unsigned short arg_size;
  18.     unsigned short env_count;
  19.     unsigned short env_size;
  20.     unsigned short mode;
  21. };
  22.  
  23. int __spawnve(struct _new_proc * np)
  24. {
  25.     int ret_v;
  26.  
  27.     __asm__("movl   %1, %%edx \n\t"
  28.         "movw   $0x7F06, %%ax \n\t"
  29.         "int    $0x21 \n\t"
  30.         "jc     1f \n\t"
  31.         "jmp    2f \n\t"
  32.         "1: \n\t"
  33.         "movl   %0, _errno \n\t"
  34.         "movl   $-1, %0 \n\t"
  35.         "2:\n\t"
  36.   : "=a"(ret_v):"m"(np));
  37.     return ret_v;
  38. }
  39.  
  40. int spawnve(int mode, const char *name, const char *const * argv,
  41.          const char *const * envp)
  42. {
  43.     struct _new_proc np;
  44.     int i, size, n;
  45.     const char *const * p;
  46.     char *d;
  47.     char exe[512];
  48.  
  49.     np.mode = mode;
  50.     strcpy(exe, name);
  51.     np.fname_off = (unsigned long) exe;
  52.  
  53.     if (envp == NULL)
  54.     envp = (const char *const *) environ;
  55.  
  56.     for (size = 1, n = 0, p = envp; *p != NULL; ++p) {
  57.     ++n;
  58.     size += 1 + strlen(*p);
  59.     }
  60.  
  61.     d = alloca(size);
  62.     np.env_count = n;
  63.     np.env_size = size;
  64.     np.env_off = (unsigned long) d;
  65.  
  66.     for (p = envp; *p != NULL; ++p) {
  67.     i = strlen(*p);
  68.     (void) memcpy(d, *p, i + 1);
  69.     d += i + 1;
  70.     }
  71.  
  72.     *d = 0;
  73.     size = 0;
  74.     n = 0;
  75.     for (p = argv; *p != NULL; ++p) {
  76.     ++n;
  77.     size += 2 + strlen(*p);
  78.     }
  79.     d = alloca(size);
  80.  
  81.     np.arg_count = n;
  82.     np.arg_size = size;
  83.     np.arg_off = (unsigned long) d;
  84.  
  85.     for (p = argv; *p != NULL; ++p) {
  86.     i = strlen(*p);
  87.     *d++ = 0xff;
  88.     (void) memcpy(d, *p, i + 1);
  89.     d += i + 1;
  90.     }
  91.  
  92.     i = __spawnve(&np);
  93.     return (i);
  94. }
  95.  
  96. int spawnvpe(int mode, const char *name, const char *const * argv,
  97.           const char *const * envp)
  98. {
  99.     char exe[512];
  100.     char path[512];
  101.  
  102.     strcpy(exe, name);
  103.     search_path(exe, path);
  104.     return (spawnve(mode, path, argv, envp));
  105. }
  106.  
  107. int spawnl(int mode, const char *name, const char *arg0,...)
  108. {
  109.     va_list vl;
  110.     int r;
  111.  
  112.     va_start(vl, name);
  113.     r = spawnv(mode, name, (const char *const *) vl);
  114.     va_end(vl);
  115.     return (r);
  116. }
  117.  
  118. int spawnle(int mode, const char *name, const char *arg0,...)
  119. {
  120.     va_list vl;
  121.     const char *const * env_ptr;
  122.     int r;
  123.  
  124.     va_start(vl, name);
  125.     while (va_arg(vl, char *) !=NULL)
  126.     ;
  127.     env_ptr = va_arg(vl, const char *const *);
  128.     va_end(vl);
  129.     va_start(vl, name);
  130.     r = spawnve(mode, name, (const char *const *) vl, env_ptr);
  131.     va_end(vl);
  132.     return (r);
  133. }
  134.  
  135. int spawnlp(int mode, const char *name, const char *arg0,...)
  136. {
  137.     va_list vl;
  138.     int r;
  139.  
  140.     va_start(vl, name);
  141.     r = spawnvp(mode, name, (const char *const *) vl);
  142.     va_end(vl);
  143.     return (r);
  144. }
  145.  
  146. int spawnlpe(int mode, const char *name, const char *arg0,...)
  147. {
  148.     va_list vl;
  149.     const char *const * env_ptr;
  150.     int r;
  151.  
  152.     va_start(vl, name);
  153.     while (va_arg(vl, char *) !=NULL)
  154.      /* do nothing */ ;
  155.     env_ptr = va_arg(vl, const char *const *);
  156.     va_end(vl);
  157.     va_start(vl, name);
  158.     r = spawnvpe(mode, name, (const char *const *) vl, env_ptr);
  159.     va_end(vl);
  160.     return (r);
  161. }
  162. int spawnv(int mode, const char *name, const char *const * argv)
  163. {
  164.     return (spawnve(mode, name, argv, NULL));
  165. }
  166. int spawnvp(int mode, const char *name, const char *const * argv)
  167. {
  168.     return (spawnvpe(mode, name, argv, NULL));
  169. }
  170.  
  171. void search_path(char *file, char *path)
  172. {
  173.     char *envp, *end;
  174.     int i, len;
  175.   
  176.     strcpy (path, file);
  177.     len = strlen (file);
  178.     if (access (path, 4) == 0)
  179.     return;
  180.     envp = getenv("PATH");
  181.     if (envp != NULL)
  182.     for (;;) {
  183.         while (*envp == ' ' || *envp == '\t')
  184.         ++envp;
  185.         if (*envp == 0)
  186.         break;
  187.         end = envp;
  188.         while (*end != 0 && *end != ';')
  189.         ++end;
  190.         i = end - envp;
  191.         while (i>0 && (envp[i-1] == ' ' || envp[i-1] == '\t'))
  192.         --i;
  193.         if (i != 0) {
  194.         memcpy (path, envp, i);
  195.         if (envp[i-1] != '/' && envp[i-1] != '\\' && envp[i-1] != ':')
  196.             path[i++] = '\\';
  197.         strcpy (path+i, file);
  198.         if (access (path, 4) == 0)
  199.             return;
  200.         strcat (path+i+len, ".exe");
  201.         if (access (path, 4) == 0)
  202.             return;
  203.         }
  204.         if (*end == 0) break;
  205.         envp = end + 1;
  206.     }
  207.     path[0] = 0;
  208. }
  209.  
  210.